target_include_directories(${dest_target} SYSTEM INTERFACE $<GENEX_EVAL:$<TARGET_PROPERTY:${source_target_de_alias},INTERFACE_SYSTEM_INCLUDE_DIRECTORIES>>)

target_include_directories(OgreAssimpConverter PRIVATE $<TARGET_PROPERTY:fix::assimp,INTERFACE_INCLUDE_DIRECTORIES>)

add_custom_command(OUTPUT "${apk_file}"
    COMMAND SdlAndroid::apksigner sign
      --ks "$<TARGET_PROPERTY:${arg_KEYSTORE},OUTPUT>"
      --ks-pass pass:android --in "$<TARGET_PROPERTY:${APK_IN},OUTPUT>" --out "${apk_file}"
    DEPENDS "$<TARGET_PROPERTY:${APK_IN},OUTPUT>" "$<TARGET_PROPERTY:${arg_KEYSTORE},OUTPUT>"
    BYPRODUCTS "${apk_file}.idsig"
  )

add_custom_command(OUTPUT "${apk_file}"
    ${commands}
    DEPENDS ${arg_NATIVE_LIBS} ${depends} "$<TARGET_PROPERTY:${arg_APK_IN},OUTPUT>"
    WORKING_DIRECTORY "${workdir}"
  )

add_custom_command(OUTPUT "${apk_file}"
    ${commands}
    DEPENDS ${arg_NATIVE_LIBS} ${depends} "$<TARGET_PROPERTY:${arg_APK_IN},OUTPUT>"
    WORKING_DIRECTORY "${workdir}"
  )

add_custom_command(
        OUTPUT ${pcm}
        COMMAND ${CMAKE_CXX_COMPILER}
                -std=c++${std} -x c++-module --precompile -c
                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
        # Required by the -I generator expression above.
        COMMAND_EXPAND_LISTS
        DEPENDS ${src})

target_include_directories(${PROJECT_NAME} PRIVATE $<TARGET_PROPERTY:eCAL::core,INCLUDE_DIRECTORIES>)

add_link_options(
		"/opt:ref" # Eliminate unreferenced functions and data
		"/opt:icf" # Perform identical COMDAT folding
		"/nodefaultlib:msvcrt"
		$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:/TSAWARE>
		"/LARGEADDRESSAWARE"
	)

include_directories($<TARGET_PROPERTY:Qt5::WebEngineWidgets,INTERFACE_INCLUDE_DIRECTORIES>)

target_compile_features(plugins PRIVATE $<TARGET_PROPERTY:apps,INTERFACE_COMPILE_FEATURES> $<TARGET_PROPERTY:framework,INTERFACE_COMPILE_FEATURES>)

target_compile_options(${TARGET}_version PRIVATE
        $<TARGET_PROPERTY:${TARGET},INTERFACE_COMPILE_OPTIONS>
        $<TARGET_PROPERTY:${TARGET},COMPILE_OPTIONS>)

add_compile_options("$<$<STREQUAL:$<TARGET_PROPERTY:LINKER_LANGUAGE>,CXX>:-std=c++14>")

target_include_directories(mbedtls
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/repo/include>
    PRIVATE
        ${OT_PUBLIC_INCLUDES}
        $<TARGET_PROPERTY:ot-config,INTERFACE_INCLUDE_DIRECTORIES>
)

target_include_directories(${us_bench_test_exe_name} PRIVATE $<TARGET_PROPERTY:util,INCLUDE_DIRECTORIES>)

target_include_directories(${TARGET_BASE_NAME}_${OPT} PRIVATE $<TARGET_PROPERTY:${TARGET_BASE_NAME},INCLUDE_DIRECTORIES>)

target_include_directories(3index
    PUBLIC
      $<TARGET_PROPERTY:gauxc::gauxc,INTERFACE_INCLUDE_DIRECTORIES>
    )

target_link_options(
    Cef::LibCef
    INTERFACE
    "${CEF_LINKER_FLAGS}"
    "$<IF:$<CONFIG:Debug>,${CEF_LINKER_FLAGS_DEBUG},${CEF_LINKER_FLAGS_RELEASE}>"
    "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:${CEF_EXE_LINKER_FLAGS};$<IF:$<CONFIG:Debug>,${CEF_EXE_LINKER_FLAGS_DEBUG},${CEF_EXE_LINKER_FLAGS_RELEASE}>>"
    "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:${CEF_SHARED_LINKER_FLAGS};$<IF:$<CONFIG:Debug>,${CEF_SHARED_LINKER_FLAGS_DEBUG},${CEF_SHARED_LINKER_FLAGS_RELEASE}>>"
    "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:${CEF_SHARED_LINKER_FLAGS};$<IF:$<CONFIG:Debug>,${CEF_SHARED_LINKER_FLAGS_DEBUG},${CEF_SHARED_LINKER_FLAGS_RELEASE}>>"
)

target_include_directories(core_iaa
    PRIVATE ${UUID_DIR}
    PUBLIC $<BUILD_INTERFACE:${QPL_SRC_DIR}/core-iaa/include>
    PUBLIC $<BUILD_INTERFACE:${QPL_SRC_DIR}/core-iaa/sources/include>
    PRIVATE $<BUILD_INTERFACE:${QPL_PROJECT_DIR}/include> # status.h in own_checkers.h
    PRIVATE $<TARGET_PROPERTY:qpl_c_api,INTERFACE_INCLUDE_DIRECTORIES> # for own_checkers.h
    PRIVATE $<TARGET_PROPERTY:qplcore_sw_dispatcher,INTERFACE_INCLUDE_DIRECTORIES>)

target_include_directories(cpptraj_common_obj PRIVATE $<TARGET_PROPERTY:fftw,INTERFACE_INCLUDE_DIRECTORIES>)

target_include_directories ( COLAMD PUBLIC
        "$<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>" )

add_compile_options("$<$<AND:$<NOT:$<OR:$<STREQUAL:$<TARGET_PROPERTY:NAME>,nanobind-static>,$<STREQUAL:$<TARGET_PROPERTY:NAME>,openvdb_python>,$<STREQUAL:$<TARGET_PROPERTY:NAME>,nanovdb_python>>>,$<COMPILE_LANG_AND_ID:CXX,GNU>>:-Wcast-qual>")

target_include_directories(
      ${name}
      PRIVATE "$<TARGET_PROPERTY:libswoc::libswoc,INCLUDE_DIRECTORIES>"
              "$<TARGET_PROPERTY:libswoc::libswoc,INTERFACE_INCLUDE_DIRECTORIES>"
              "$<TARGET_PROPERTY:yaml-cpp::yaml-cpp,INCLUDE_DIRECTORIES>"
              "$<TARGET_PROPERTY:yaml-cpp::yaml-cpp,INTERFACE_INCLUDE_DIRECTORIES>"
    )

target_compile_features(${dictionary} PRIVATE
      $<TARGET_PROPERTY:${ARG_MODULE},COMPILE_FEATURES>)

TARGET_COMPILE_OPTIONS(mysqlxmessages_shared
  PUBLIC $<TARGET_PROPERTY:mysqlxmessages,INTERFACE_COMPILE_OPTIONS>)

TARGET_COMPILE_OPTIONS(mysqlxmessages_shared
  PUBLIC $<TARGET_PROPERTY:mysqlxmessages,INTERFACE_COMPILE_OPTIONS>)

target_include_directories(OMPyExecutionSessionBase
  PRIVATE
  $<TARGET_PROPERTY:onnx,INCLUDE_DIRECTORIES>
  )

target_include_directories(yarp_audioRecorder_nws_yarp PRIVATE $<TARGET_PROPERTY:IAudioGrabberMsgs,INTERFACE_INCLUDE_DIRECTORIES>)

target_include_directories(adm_export_source_VST3
    PRIVATE
    ${CMAKE_SOURCE_DIR}/ear-production-suite-plugins/lib/include
    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/submodules/readerwriterqueue>
    $<TARGET_PROPERTY:adm,INTERFACE_INCLUDE_DIRECTORIES>
)

target_include_directories(metavision_cx3_updater 
    PRIVATE
        $<TARGET_PROPERTY:metavision_hal_psee_plugin_obj,INTERFACE_INCLUDE_DIRECTORIES>
)

target_sources(${dst_target} PRIVATE $<TARGET_PROPERTY:${src_target},INTERFACE_SOURCES>)

target_compile_definitions(3d-viewer_navlib PRIVATE
        $<TARGET_PROPERTY:3DxWare::Navlib,INTERFACE_COMPILE_DEFINITIONS>
    )

set_target_properties(${dest_target} PROPERTIES
            XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER
                $<TARGET_PROPERTY:${source_target},JUCE_BUNDLE_ID>)

string(JOIN "" flag_genex
        "$<IF:"
            "${check_default_genex},"
            "${default_flag},"
            "$<IF:"
                "$<BOOL:$<TARGET_PROPERTY:_qt_internal_use_exceptions>>,"
                "${enable_flag},"
                "${disable_flag}"
            ">"
        ">"
    )

add_custom_command(
          OUTPUT ${pcm}
          COMMAND ${CMAKE_CXX_COMPILER}
          -std=c++${std} -x c++-module --precompile -c
          -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
          "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
          # Required by the -I generator expression above.
          COMMAND_EXPAND_LISTS
          DEPENDS ${src})

add_compile_options($<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>)

add_custom_command(
                OUTPUT "${OUT_JAR}"
                COMMAND ${CMAKE_COMMAND} -E rm -rf "${classes_path}"
                COMMAND ${CMAKE_COMMAND} -E make_directory "${classes_path}"
                COMMAND ${Java_JAVAC_EXECUTABLE}
                    -source 1.8 -target 1.8
                    -bootclasspath "$<TARGET_PROPERTY:SDL3::Jar,JAR_FILE>"
                    "${JAVA_PACKAGE_DIR}/SDLEntryTestActivity.java"
                    "${JAVA_PACKAGE_DIR}/SDLTestActivity.java"
                    $<TARGET_PROPERTY:${TEST}-apk-linked,JAVA_R>
                    -cp "$<TARGET_PROPERTY:SDL3::Jar,JAR_FILE>:${SDL_ANDROID_PLATFORM_ANDROID_JAR}"
                    -d "${classes_path}"
                COMMAND ${Java_JAR_EXECUTABLE} cf "${OUT_JAR}" -C "${classes_path}" .
                DEPENDS $<TARGET_PROPERTY:${TEST}-apk-linked,OUTPUTS> "$<TARGET_PROPERTY:SDL3::Jar,JAR_FILE>" "${JAVA_PACKAGE_DIR}/SDLTestActivity.java" "${JAVA_PACKAGE_DIR}/SDLEntryTestActivity.java"
            )

target_compile_definitions(jive-benchmarking
                           PRIVATE JIVE_GUI_ITEMS_HAVE_STYLE_SHEETS=1
                                   JIVE_UNIT_TESTS=0
                                   JUCE_APPLICATION_NAME="$<TARGET_PROPERTY:jive-benchmarking,JUCE_PRODUCT_NAME>"
                                   JUCE_APPLICATION_VERSION="$<TARGET_PROPERTY:jive-benchmarking,JUCE_VERSION>"
)

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/.staging-stamp APPEND
        DEPENDS ${MACPKG_SOURCE_BUNDLE}
        COMMAND ${CMAKE_COMMAND} -E copy_directory $<TARGET_BUNDLE_DIR:${MACPKG_SOURCE_BUNDLE}>
            ${CMAKE_CURRENT_BINARY_DIR}/staging/$<TARGET_PROPERTY:${MACPKG_SOURCE_BUNDLE},OUTPUT_NAME>.app
        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/.staging-stamp
    )

TARGET_INCLUDE_DIRECTORIES(${TARGET_LIB} SYSTEM PRIVATE
          $<TARGET_PROPERTY:${lib},INTERFACE_INCLUDE_DIRECTORIES>)

target_include_directories(middle_layer_lib
    PRIVATE ${UUID_DIR}
    PUBLIC $<BUILD_INTERFACE:${QPL_SRC_DIR}/middle-layer>
    PUBLIC $<TARGET_PROPERTY:_qpl,INTERFACE_INCLUDE_DIRECTORIES>
    PRIVATE $<TARGET_PROPERTY:qpl_c_api,INTERFACE_INCLUDE_DIRECTORIES>
    PUBLIC $<TARGET_PROPERTY:qplcore_sw_dispatcher,INTERFACE_INCLUDE_DIRECTORIES>
    PUBLIC $<TARGET_PROPERTY:isal,INTERFACE_INCLUDE_DIRECTORIES>
    PUBLIC $<TARGET_PROPERTY:core_iaa,INTERFACE_INCLUDE_DIRECTORIES>)

add_custom_command(
        OUTPUT ${obj}
        COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
                -c -o ${obj} ${pcm}
        DEPENDS ${pcm})

target_compile_definitions(${objlib}
    PRIVATE $<TARGET_PROPERTY:${MONERO_ADD_LIBRARY_NAME},INTERFACE_COMPILE_DEFINITIONS>)

set_property(TARGET RawSpeed::OpenMP_CXX PROPERTY INTERFACE_LINK_LIBRARIES  $<TARGET_PROPERTY:OpenMP::OpenMP_CXX,INTERFACE_LINK_LIBRARIES>)

target_include_directories(HarfBuzzFontTest SYSTEM PRIVATE
    $<TARGET_PROPERTY:HarfBuzz::HarfBuzz,INTERFACE_INCLUDE_DIRECTORIES>)

target_include_directories(MantidQtIconsQt5 PUBLIC $<TARGET_PROPERTY:Mantid::Kernel,INTERFACE_INCLUDE_DIRECTORIES>)

target_compile_options( ${LIB_NAME}_arm_simd PRIVATE $<$<TARGET_EXISTS:nlohmann_json::nlohmann_json>:$<TARGET_PROPERTY:nlohmann_json::nlohmann_json,INTERFACE_COMPILE_OPTIONS>> )

target_include_directories(${tgt} SYSTEM PRIVATE
    $<BUILD_INTERFACE:$<TARGET_PROPERTY:phmap,INTERFACE_INCLUDE_DIRECTORIES>>
  )

add_custom_command(OUTPUT "${apk_file}"
    COMMAND SdlAndroid::apksigner sign
      --ks "$<TARGET_PROPERTY:${arg_KEYSTORE},OUTPUT>"
      --ks-pass pass:android --in "$<TARGET_PROPERTY:${APK_IN},OUTPUT>" --out "${apk_file}"
    DEPENDS "$<TARGET_PROPERTY:${APK_IN},OUTPUT>" "$<TARGET_PROPERTY:${arg_KEYSTORE},OUTPUT>"
    BYPRODUCTS "${apk_file}.idsig"
  )

target_compile_definitions(
                ${object_library} PUBLIC
                $<TARGET_PROPERTY:${dependency},INTERFACE_COMPILE_DEFINITIONS>)

TARGET_INCLUDE_DIRECTORIES(${TO}
    PUBLIC $<TARGET_PROPERTY:${FROM},INCLUDE_DIRECTORIES>)

TARGET_INCLUDE_DIRECTORIES(${T}
  PRIVATE $<TARGET_PROPERTY:routing,INCLUDE_DIRECTORIES>)

include_directories($<TARGET_PROPERTY:tigl3_cpp,INTERFACE_INCLUDE_DIRECTORIES>)

add_custom_command(
          OUTPUT ${obj}
          COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
                  -c -o ${obj} ${pcm}
          DEPENDS ${pcm})

add_custom_command(
    OUTPUT
        ${CHRONIK_BRIDGE_GENERATED_CPP_FILES}
        ${CHRONIK_LIB_GENERATED_CPP_FILES}
    COMMAND
        "${CMAKE_COMMAND}"
        -E env
        "echo" "Generating cxx bridge files"
    DEPENDS $<TARGET_PROPERTY:chronik_lib,INTERFACE_LINK_LIBRARIES>
)

set_target_properties(Boost::filesystem PROPERTIES
  INTERFACE_COMPILE_DEFINITIONS "BOOST_FILESYSTEM_NO_LIB;\$<\$<STREQUAL:\$<TARGET_PROPERTY:Boost::filesystem,TYPE>,SHARED_LIBRARY>:BOOST_FILESYSTEM_DYN_LINK=1>;\$<\$<STREQUAL:\$<TARGET_PROPERTY:Boost::filesystem,TYPE>,STATIC_LIBRARY>:BOOST_FILESYSTEM_STATIC_LINK=1>"
  INTERFACE_COMPILE_FEATURES "cxx_rvalue_references;cxx_strong_enums;cxx_noexcept;cxx_nullptr;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_deleted_functions;cxx_default_function_template_args;cxx_final;cxx_override"
  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
  INTERFACE_LINK_LIBRARIES "Boost::assert;Boost::config;Boost::container_hash;Boost::detail;Boost::io;Boost::iterator;Boost::smart_ptr;Boost::system;Boost::type_traits"
)

target_compile_definitions(${target} PUBLIC $<TARGET_PROPERTY:${fromTarget},INTERFACE_COMPILE_DEFINITIONS>)

target_include_directories(pfMetalPipelineShadersMSL23
    PRIVATE
    $<TARGET_PROPERTY:pnNucleusInc,INTERFACE_INCLUDE_DIRECTORIES>
)

target_include_directories(ortcustomops PUBLIC "$<TARGET_PROPERTY:noexcep_operators,INTERFACE_INCLUDE_DIRECTORIES>")

add_custom_command(
        OUTPUT ${pcm}
        COMMAND ${CMAKE_CXX_COMPILER}
                -std=c++${std} -x c++-module --precompile -c
                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
        # Required by the -I generator expression above.
        COMMAND_EXPAND_LISTS
        DEPENDS ${src})

TARGET_INCLUDE_DIRECTORIES(routerfuzz_router_uri
    PRIVATE
    $<TARGET_PROPERTY:router_lib,INCLUDE_DIRECTORIES>
    )

target_include_directories(opencl_sort_by_key_${SBK_TYPE}
        SYSTEM INTERFACE
          $<TARGET_PROPERTY:Forge::forge,INCLUDE_DIRECTORIES>
      )

add_custom_command(TARGET openxr_loader POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:openxr_loader> $<TARGET_PROPERTY:conformance_cli,BINARY_DIR>
    )

target_compile_features (glog_internal PUBLIC $<TARGET_PROPERTY:glog,COMPILE_FEATURES>)

TARGET_INCLUDE_DIRECTORIES(routerfuzz_base64
    PRIVATE $<TARGET_PROPERTY:http_common,INCLUDE_DIRECTORIES>)

target_compile_options(seal PRIVATE $<TARGET_PROPERTY:HEXL::hexl,INTERFACE_COMPILE_OPTIONS>)

target_compile_options(quda_cpp PRIVATE $<TARGET_PROPERTY:quda,COMPILE_OPTIONS>)

target_include_directories(${__TARGET_ADD_DEPENDENCY_TARGET} 
            PRIVATE
                $<TARGET_PROPERTY:Qt5::${qt_component},INCLUDE_DIRECTORIES>
            )

add_link_options(
		"/opt:ref" # Eliminate unreferenced functions and data
		"/opt:icf" # Perform identical COMDAT folding
		"/nodefaultlib:msvcrt"
		$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:/TSAWARE>
		"/LARGEADDRESSAWARE"
	)

install(FILES $<TARGET_OBJECTS:${fq_target_name}>
          DESTINATION ${LIBC_INSTALL_LIBRARY_DIR}
          RENAME $<TARGET_PROPERTY:${fq_target_name},OUTPUT_NAME>
          COMPONENT libc)

target_include_directories(${TEST_NAME}
        PRIVATE $<TARGET_PROPERTY:${PXR_PACKAGE},INCLUDE_DIRECTORIES>
    )

get_filename_component( _libfile "$<TARGET_PROPERTY:${_dep},IMPORTED_SONAME_RELEASE>" NAME )

target_include_directories(${target} PUBLIC $<TARGET_PROPERTY:${library},SOURCE_DIR>/include)

add_custom_command(TARGET ${MBF_TARGET} POST_BUILD
            WORKING_DIRECTORY $<TARGET_PROPERTY:${MBF_TARGET},LIBRARY_OUTPUT_DIRECTORY>
            COMMAND ${CMAKE_COMMAND} -E copy
                ${CLAP_WRAPPER_CMAKE_CURRENT_SOURCE_DIR}/cmake/macBundlePkgInfo
                "$<TARGET_FILE_DIR:${MBF_TARGET}>/../PkgInfo")

string(CONFIGURE [=[
        #include <cmrc/cmrc.hpp>
        #include <map>
        #include <utility>

        namespace cmrc {
        namespace @ARG_NAMESPACE@ {

        namespace res_chars {
        // These are the files which are available in this resource library
        $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_EXTERN_DECLS>,
        >
        }

        namespace {

        const cmrc::detail::index_type&
        get_root_index() {
            static cmrc::detail::directory root_directory_;
            static cmrc::detail::file_or_directory root_directory_fod{root_directory_};
            static cmrc::detail::index_type root_index;
            root_index.emplace("", &root_directory_fod);
            struct dir_inl {
                class cmrc::detail::directory& directory;
            };
            dir_inl root_directory_dir{root_directory_};
            (void)root_directory_dir;
            $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_MAKE_DIRS>,
            >
            $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_MAKE_FILES>,
            >
            return root_index;
        }

        }

        cmrc::embedded_filesystem get_filesystem() {
            static auto& index = get_root_index();
            return cmrc::embedded_filesystem{index};
        }

        } // @ARG_NAMESPACE@
        } // cmrc
    ]=] cpp_content @ONLY)

list(APPEND import_args -I "$<TARGET_PROPERTY:${target},BINARY_DIR>")

target_include_directories(${targetname} PUBLIC
            $<TARGET_PROPERTY:${deptargetname},INTERFACE_INCLUDE_DIRECTORIES>)

set("${outVar}" "$<TARGET_PROPERTY:${inputExpr}>" PARENT_SCOPE)

target_sources(
    rtapi_app PRIVATE ${SOURCE_FILES} ${PRIVATE_HEADER_FILES}
                      $<TARGET_PROPERTY:rtapi_support,INTERFACE_SOURCES>)

target_include_directories ( KLU PUBLIC
        "$<TARGET_PROPERTY:SuiteSparse::AMD,INTERFACE_INCLUDE_DIRECTORIES>" )

add_compile_options(
    $<$<STREQUAL:$<TARGET_PROPERTY:CXX_EXCEPTIONS>,ON>:/EHsc>
    $<$<STREQUAL:$<TARGET_PROPERTY:CXX_RTTI>,OFF>:/GR->
    $<$<STREQUAL:$<TARGET_PROPERTY:CXX_STATIC_RUNTIME>,OFF>:$<$<CONFIG:Debug>:/MDd>$<$<NOT:$<CONFIG:Debug>>:/MD>>
    $<$<STREQUAL:$<TARGET_PROPERTY:CXX_STATIC_RUNTIME>,ON>:$<$<CONFIG:Debug>:/MTd>$<$<NOT:$<CONFIG:Debug>>:/MT>>
  )

install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftdoc
    DESTINATION lib/${swift}/${swift_os}/${module_name}.swiftmodule
    RENAME ${SwiftFoundation_MODULE_TRIPLE}.swiftdoc)

add_library(checking_${target_in} $<TARGET_PROPERTY:${target_in},SOURCES>)

target_compile_definitions(test_log_admin PRIVATE -DLOG_ADMIN_BUNDLE=\"$<TARGET_PROPERTY:log_admin,BUNDLE_FILE>\")

target_compile_definitions(
    ${SCP_ARCHITECTURE_TARGET}
    PRIVATE
        $<TARGET_PROPERTY:${SCP_FIRMWARE_TARGET},INTERFACE_COMPILE_DEFINITIONS>)

add_custom_command(OUTPUT ${SOURCE_TARGET}-version.json
        COMMAND ${CMAKE_COMMAND}
            -DSRC_DIR=${CMAKE_SOURCE_DIR}
            -DSRC_FILE=${CMAKE_SOURCE_DIR}/config/version_rt1051.json.cmake_template
            -DDST_FILE=${CMAKE_BINARY_DIR}/${SOURCE_TARGET}-version.json
            -DBOOTLOADER_FILENAME=ecoboot.bin
            -DBOOTLOADER_FILE=${SYSROOT_BIN_PATH}/ecoboot.bin
            -DOS_FILENAME=os.bin
            -DOS_FILE=$<TARGET_PROPERTY:${SOURCE_TARGET},BIN_FILE>
            -DOS_VERSION=${PROJECT_VERSION}
            -DRECOVERY_FILENAME=recovery.bin
            -DRECOVERY_FILE=${SYSROOT_BIN_PATH}/recovery.bin
            -DOS_VERSION_MAJOR=${OS_VERSION_MAJOR}
            -DOS_VERSION_MINOR=${OS_VERSION_MINOR}
            -DOS_VERSION_PATCH=${OS_VERSION_PATCH}
            -DOS_VERSION_LABEL=${OS_VERSION_LABEL}
            -DECOBOOT_BIN_VERSION=${ECOBOOT_BIN_VERSION}
            -DRECOVERY_BIN_VERSION=${RECOVERY_BIN_VERSION}
            -B ${CMAKE_BINARY_DIR}
            -P ${CMAKE_SOURCE_DIR}/cmake/modules/ConfigureVersionJson.cmake
        COMMAND python3 ${CMAKE_SOURCE_DIR}/tools/add_dbs_to_version_json.py
            --input_path ${CMAKE_SOURCE_DIR}/products/${SOURCE_TARGET}/services/db/databases/databases.json
            --output_path ${CMAKE_BINARY_DIR}/${SOURCE_TARGET}-version.json
            --product ${SOURCE_TARGET}
        DEPENDS ecoboot.bin-target
        DEPENDS recovery.bin-target
        DEPENDS ${SOURCE_TARGET}-boot.bin
    )

target_compile_options(algorithmic_tests
        PRIVATE $<TARGET_PROPERTY:tests_common,COMPILE_OPTIONS>)

install(
    FILES $<TARGET_PROPERTY:${target},Swift_MODULE_DIRECTORY>/${module}.swiftmodule
    DESTINATION ${INSTALL_SWIFT_MODULE_DIR}/${module}.swiftmodule
    RENAME ${dispatch_MODULE_TRIPLE}.swiftmodule)

add_compile_options($<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,STATIC_LIBRARY>:/deterministic>)

add_compile_options($<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>)

ExternalProject_Add (grpc_src
      PREFIX ${nih_cache_path}
      GIT_REPOSITORY https://github.com/grpc/grpc.git
      GIT_TAG v1.25.0
      CMAKE_ARGS
        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
        $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
        $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
        $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>
        $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
        -DCMAKE_DEBUG_POSTFIX=_d
        $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
        -DgRPC_BUILD_TESTS=OFF
        -DgRPC_BENCHMARK_PROVIDER=""
        -DgRPC_BUILD_CSHARP_EXT=OFF
        -DgRPC_MSVC_STATIC_RUNTIME=ON
        -DgRPC_INSTALL=OFF
        -DgRPC_CARES_PROVIDER=package
        -Dc-ares_DIR=${cares_binary_dir}/_installed_/lib/cmake/c-ares
        -DgRPC_SSL_PROVIDER=package
        -DOPENSSL_ROOT_DIR=${OPENSSL_ROOT_DIR}
        -DgRPC_PROTOBUF_PROVIDER=package
        -DProtobuf_USE_STATIC_LIBS=$<IF:$<AND:$<BOOL:${Protobuf_FOUND}>,$<NOT:$<BOOL:${static}>>>,OFF,ON>
        -DProtobuf_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>,:_:>
        -DProtobuf_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_RELEASE>>
        -DProtobuf_PROTOC_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_RELEASE>>
        -DProtobuf_PROTOC_EXECUTABLE=$<TARGET_PROPERTY:protobuf::protoc,IMPORTED_LOCATION>
        -DgRPC_ZLIB_PROVIDER=package
        $<$<NOT:$<BOOL:${has_zlib}>>:-DZLIB_ROOT=${zlib_binary_dir}/_installed_>
        $<$<BOOL:${MSVC}>:
          "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
          "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
        >
      LOG_BUILD ON
      LOG_CONFIGURE ON
      BUILD_COMMAND
        ${CMAKE_COMMAND}
        --build .
        --config $<CONFIG>
        --parallel ${ep_procs}
        $<$<BOOL:${is_multiconfig}>:
          COMMAND
            ${CMAKE_COMMAND} -E copy
            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc++${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}address_sorting$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}gpr$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
            <BINARY_DIR>/$<CONFIG>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
            <BINARY_DIR>
          >
      LIST_SEPARATOR :_:
      TEST_COMMAND ""
      INSTALL_COMMAND ""
      DEPENDS c-ares_src
      BUILD_BYPRODUCTS
        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}_d${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}_d${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}address_sorting${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}address_sorting_d${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}gpr${ep_lib_suffix}
        <BINARY_DIR>/${ep_lib_prefix}gpr_d${ep_lib_suffix}
        <BINARY_DIR>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
    )

target_compile_definitions(${APP_NAME} PUBLIC
# JUCE_WEB_BROWSER and JUCE_USE_CURL would be on by default, but you might not need them.
JUCE_WEB_BROWSER=0                          # If you remove this, add `NEEDS_WEB_BROWSER TRUE` to the `juce_add_gui_app` call
JUCE_USE_CURL=0                             # If you remove this, add `NEEDS_CURL TRUE` to the `juce_add_gui_app` call
JUCE_APPLICATION_NAME_STRING="$<TARGET_PROPERTY:${APP_NAME},JUCE_PROJECT_NAME>"
JUCE_APPLICATION_VERSION_STRING="$<TARGET_PROPERTY:${APP_NAME},JUCE_VERSION>"
JUCE_DISPLAY_SPLASH_SCREEN=0
JUCE_STRICT_REFCOUNTEDPOINTER=1
JUCE_VST3_CAN_REPLACE_VST2=0                # If true requires vst2 SDK which I don't have so it has to be false
JUCE_MODAL_LOOPS_PERMITTED=1
DONT_SET_USING_JUCE_NAMESPACE=1
JUCE_DONT_DECLARE_PROJECTINFO=1
JUCE_TARGET_HAS_BINARY_DATA=1
)

add_link_options($<TARGET_PROPERTY:linker,lto_arguments>)

target_include_directories(symbol_export_test PRIVATE
        "$<BUILD_INTERFACE:$<TARGET_PROPERTY:security_api,INTERFACE_INCLUDE_DIRECTORIES>>"
        "$<BUILD_INTERFACE:$<TARGET_PROPERTY:security_core,INTERFACE_INCLUDE_DIRECTORIES>>")

add_custom_command(OUTPUT "${apk_file}"
    COMMAND SdlAndroid::zipalign -f 4 "$<TARGET_PROPERTY:${APK_IN},OUTPUT>" "${apk_file}"
    DEPENDS "$<TARGET_PROPERTY:${APK_IN},OUTPUT>"
  )